package com.test;

/**
 * @author yulongtian
 * @create 2025-01-15 15:09
 */

import java.util.ArrayList;
import java.util.List;

public class ValueConverter {

    /**
     * 将值转换为字符串格式
     * <p>
     * 5 - 5i
     * <p>
     * [1,1,1] - [1f,1f,1f]
     *
     * @param value 原始值
     * @return 转换后的字符串
     */
    public static String valueToString(Object value, String type) {
        if (ValueTypeEnum.INT.getCode().equals(type)) {
            return value + "i"; // 整数类型
        } else if (ValueTypeEnum.FLOAT.getCode().equals(type)) {
            return value + "f"; // 浮点数类型
        } else if (ValueTypeEnum.STRING.getCode().equals(type)) {
            return "\"" + value + "\""; // 字符串类型
        } else if (ValueTypeEnum.BOOLEAN.getCode().equals(type)) {
            return value.toString(); // 布尔类型
        } else if (ValueTypeEnum.LIST.getCode().equals(type)) {
            return listToString((String) value, ValueTypeEnum.FLOAT.getCode()); // 列表类型
        } else {
            throw new IllegalArgumentException("Unsupported type: " + value.getClass().getName());
        }
    }

    /**
     * 将字符串格式的值转换为原始类型
     *
     * @param str 字符串格式的值
     * @return 原始值
     */
    public static Object stringToValue(String str) {
        if (str.endsWith("i")) {
            // 整数类型
            return Integer.parseInt(str.substring(0, str.length() - 1));
        } else if (str.endsWith("f")) {
            // 浮点数类型
            return Float.parseFloat(str.substring(0, str.length() - 1));
        } else if (str.startsWith("\"") && str.endsWith("\"")) {
            // 字符串类型
            return str.substring(1, str.length() - 1);
        } else if (str.equalsIgnoreCase("true") || str.equalsIgnoreCase("false")) {
            // 布尔类型
            return Boolean.parseBoolean(str);
        } else if (str.startsWith("[") && str.endsWith("]")) {
            // 列表类型
            return stringToList(str);
        } else {
            throw new IllegalArgumentException("Unsupported string format: " + str);
        }
    }


    /**
     * 将列表的字符串形式转换为特定格式的字符串
     *
     * @param listStr 列表的字符串形式（例如 "1,2,3"）
     * @param type    列表元素的类型（支持 "int", "float", "string", "boolean"）
     * @return 转换后的字符串（例如 "[1i,2i,3i]"）
     */
    private static String listToString(String listStr, String type) {
        String content = listStr.substring(1, listStr.length() - 1); // 去掉首尾的方括号
        String[] parts = content.split(",");
        StringBuilder sb = new StringBuilder("[");
        for (int i = 0; i < parts.length; i++) {
            String value = parts[i].trim();
            sb.append(valueToString(value, type)); // 根据类型转换每个元素
            if (i < parts.length - 1) {
                sb.append(",");
            }
        }
        sb.append("]");
        return sb.toString();
    }

    /**
     * 将字符串格式的列表转换为原始列表
     * [1f,1f,1f] - [1,1,1]
     *
     * @param str 字符串格式的列表
     * @return 原始列表
     */
    private static List<Object> stringToList(String str) {
        List<Object> list = new ArrayList<>();
        String content = str.substring(1, str.length() - 1); // 去掉首尾的方括号
        if (content.isEmpty()) {
            return list; // 空列表
        }
        String[] parts = content.split(",");
        for (String part : parts) {
            list.add(stringToValue(part.trim()));
        }
        return list;
    }

    private static String getValueType(String formattedStr) {
        if (formattedStr.endsWith("i")) {
            return ValueTypeEnum.INT.getCode(); // 整数类型
        } else if (formattedStr.endsWith("f")) {
            return ValueTypeEnum.FLOAT.getCode(); // 浮点数类型
        } else if (formattedStr.startsWith("\"") && formattedStr.endsWith("\"")) {
            return ValueTypeEnum.STRING.getCode(); // 字符串类型
        } else if (formattedStr.equalsIgnoreCase("true") || formattedStr.equalsIgnoreCase("false")) {
            return ValueTypeEnum.BOOLEAN.getCode(); // 布尔类型
        } else if (formattedStr.startsWith("[") && formattedStr.endsWith("]")) {
            return ValueTypeEnum.LIST.getCode(); // 列表类型
        } else {
            throw new IllegalArgumentException("Unsupported formatted string: " + formattedStr);
        }
    }

    // 测试
    public static void main(String[] args) {
        // 测试整数
        String intValue = "5";
        String intStr = valueToString(intValue, "Int");
        System.out.println("Integer to String: " + intStr); // 输出: 5i
        System.out.println("String to Integer: " + stringToValue(intStr)); // 输出: 5

        // 测试浮点数
        String floatValue = "6.0";
        String floatStr = valueToString(floatValue, "Float");
        System.out.println("Float to String: " + floatStr); // 输出: 6.0f
        System.out.println("String to Float: " + stringToValue(floatStr)); // 输出: 6.0

        // 测试字符串
        String stringValue = "\"hello\"";
        String stringStr = valueToString(stringValue, "String");
        System.out.println("String to String: " + stringStr); // 输出: "hello"
        System.out.println("String to String: " + stringToValue(stringStr)); // 输出: hello

        // 测试布尔值
        String boolValue = "true";
        String boolStr = valueToString(boolValue, "Boolean");
        System.out.println("Boolean to String: " + boolStr); // 输出: true
        System.out.println("String to Boolean: " + stringToValue(boolStr)); // 输出: true

        // 测试列表
        List<Object> listValue = new ArrayList<>();
        listValue.add(2.5f);
        listValue.add(2.5f);
        listValue.add(2.5f);
        listValue.add(2.5f);
        String listStr = valueToString(listValue.toString(), "List");
        System.out.println("List to String: " + listStr); // 输出: [1i,2.5f,"world",true]
        System.out.println("String to List: " + stringToList(listStr)); // 输出: [1, 2.5, world, true]
    }
}
